单例模式（饿汉式,懒汉式,静态内部类模式,枚举单例模式）

#单例模式（饿汉式,懒汉式,静态内部类模式,枚举单例模式）| 来源: 网络整理| 查看: 265

饿汉式

懒汉式

静态内部类

强烈推荐通过枚举实现单例模式

Java枚举简单介绍（了解枚举的朋友可以跳过这部分）

枚举单例

单例模式是 Java 中最简单，也是最基础，最常用的设计模式之一。在运行期间，保证某个类只创建一个实例，保证一个类仅有一个实例，并提供一个访问它的全局访问点。下面就来讲讲Java中的N种实现单例模式的写法。

饿汉式 /** * 饿汉式 * 类加载到内存后，就实例化一个单例，JVM保证线程安全 * 简单实用，推荐使用！ * 唯一缺点：不管用到与否，类装载时就完成实例化 * Class.forName("") * （话说你不用的，你装载它干啥） */ public class Mgr01 { private static final Mgr01 INSTANCE = new Mgr01(); private Mgr01() {}; public static Mgr01 getInstance() { return INSTANCE; } public void m() { System.out.println("m"); } public static void main(String[] args) { Mgr01 m1 = Mgr01.getInstance(); Mgr01 m2 = Mgr01.getInstance(); System.out.println(m1 == m2); } }

这是实现一个安全的单例模式的最简单粗暴的写法，这种实现方式我们称之为饿汉式。之所以称之为饿汉式，是因为肚子很饿了，想马上吃到东西，不想等待生产时间。这种写法，在类被加载的时候就把Mgr01 实例给创建出来了。

饿汉式的缺点就是，可能在还不需要此实例的时候就已经把实例创建出来了，没起到lazy loading的效果。优点就是实现简单，而且安全可靠。

懒汉式 /** * lazy loading * 也称懒汉式 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题 */ public class Mgr03 { private static Mgr03 INSTANCE; private Mgr03() { } public static Mgr03 getInstance() { if (INSTANCE == null) { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } INSTANCE = new Mgr03(); } return INSTANCE; } }

相比饿汉式，懒汉式显得没那么“饿”，在真正需要的时候再去创建实例。在getInstance方法中，先判断实例是否为空再决定是否去创建实例，看起来似乎很完美，但是存在线程安全问题。在并发获取实例的时候，可能会存在构建了多个实例的情况。所以，需要对此代码进行下改进。

/** * lazy loading * 也称懒汉式 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题 * 可以通过synchronized解决，但也带来效率下降 */ public class Mgr06 { private static volatile Mgr06 INSTANCE; //JIT private Mgr06() { } public static Mgr06 getInstance() { if (INSTANCE == null) { //双重检查 synchronized (Mgr06.class) { if(INSTANCE == null) { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } INSTANCE = new Mgr06(); } } } return INSTANCE; }

这里采用了双重校验的方式，对懒汉式单例模式做了线程安全处理。通过加锁，可以保证同时只有一个线程走到第二个判空代码中去，这样保证了只创建一个实例。这里还用到了volatile关键字来修饰Mgr06 ，其最关键的作用是防止指令重排。

静态内部类 /** * 静态内部类方式 * JVM保证单例(jvm保证其线程安全) * 加载外部类时不会加载内部类，这样可以实现懒加载 */ public class Singleton { private static class SingletonHolder { private static Singleton instance = new Singleton(); } private Singleton() { } public static Singleton getInstance() { return SingletonHolder.instance; } }

通过静态内部类的方式实现单例模式是线程安全的，同时静态内部类不会在Singleton类加载时就加载，而是在调用getInstance()方法时才进行加载，达到了懒加载的效果。

似乎静态内部类看起来已经是最完美的方法了，其实不是，可能还存在反射攻击或者反序列化攻击。且看如下代码：

/** *模拟反射攻击 */ public static void main(String[] args) throws Exception { Singleton singleton = Singleton.getInstance(); Constructor constructor = Singleton.class.getDeclaredConstructor(); constructor.setAccessible(true); Singleton newSingleton = constructor.newInstance(); System.out.println(singleton == newSingleton); }

运行结果：

通过结果看，这两个实例不是同一个，这就违背了单例模式的原则了。

除了反射攻击之外，还可能存在反序列化攻击的情况。如下：

引入依赖：

org.apache.commons commons-lang3 3.8.1

这个依赖提供了序列化和反序列化工具类。

Singleton类实现java.io.Serializable接口。

如下：

public class Singleton implements Serializable { private static class SingletonHolder { private static Singleton instance = new Singleton(); } private Singleton() { } public static Singleton getInstance() { return SingletonHolder.instance; } public static void main(String[] args) { Singleton instance = Singleton.getInstance(); byte[] serialize = SerializationUtils.serialize(instance); Singleton newInstance = SerializationUtils.deserialize(serialize); System.out.println(instance == newInstance); } }

运行结果：

强烈推荐通过枚举实现单例模式

在effective java（这本书真的很棒）中说道，最佳的单例实现模式就是枚举模式。利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。除此之外，写法还特别简单。

Java枚举简单介绍（了解枚举的朋友可以跳过这部分）

枚举的用法比较多，本文将要介绍利用枚举实现单例模式的原理，所以这里也主要介绍一些相关的基础内容。首先，枚举类似类，一个枚举可以拥有成员变量，成员方法，构造方法。先来看枚举最基本的用法：

enum Type{ A,B,C,D; }

创建enum时，编译器会自动为我们生成一个继承自java.lang.Enum的类，我们上面的enum可以简单看作：

class Type extends Enum{ public static final Type A; public static final Type B; ... }

对于上面的例子，我们可以把Type看作一个类，而把A，B，C，D看作类的Type的实例。当然，这个构建实例的过程不是我们做的，一个enum的构造方法限制是private的，也就是不允许我们调用。

“类”方法和“实例”方法

上面说到，我们可以把Type看作一个类，而把A，B。。。看作Type的一个实例。同样，在enum中，我们可以定义类和实例的变量以及方法。看下面的代码：

enum Type{ A,B,C,D; static int value; public static int getValue() { return value; } String type; public String getType() { return type; } } 在原有的基础上，添加了类方法和实例方法。我们把Type看做一个类，那么enum中静态的域和方法，都可以视作类方法。和我们调用普通的静态方法一样，这里调用类方法也是通过 Type.getValue()即可调用，访问类属性也是通过Type.value即可访问。下面的是实例方法，也就是每个实例才能调用的方法。那么实例是什么呢？没错，就是A，B，C，D。所以我们调用实例方法，也就通过 Type.A.getType()来调用就可以了。

最后，对于某个实例而言，还可以实现自己的实例方法。再看下下面的代码：

enum Type{ A{ public String getType() { return "I will not tell you"; } },B,C,D; static int value; public static int getValue() { return value; } String type; public String getType() { return type; } }

这里，A实例后面的{…}就是属于A的实例方法，可以通过覆盖原本的方法，实现属于自己的定制。除此之外，我们还可以添加抽象方法在enum中，强制ABCD都实现各自的处理逻辑:

enum Type{ A{ public String getType() { return "A"; } },B { @Override public String getType() { return "B"; } },C { @Override public String getType() { return "C"; } },D { @Override public String getType() { return "D"; } }; public abstract String getType(); } 枚举单例 /** * 枚举单例 * Effective Java 作者 Joshua * 不仅可以解决线程同步，还可以防止反序列化。 */ public enum Singleton { INSTANCE; public void m() {} public void doSomething() { System.out.println("doSomething"); } //单例测试 public static void main(String[] args) { for(int i=0; i{ System.out.println(Singleton .INSTANCE.hashCode()); }).start(); } } }

调用方法：

public class Main { public static void main(String[] args) { Singleton.INSTANCE.doSomething(); } }

直接通过Singleton.INSTANCE.doSomething()的方式调用即可。方便、简洁又安全。

【本文地址】

公司简介

联系我们

今日新闻

推荐新闻

专题文章